#pragma once

#include<iostream>
#include<string>
#include<jsoncpp/json/json.h>
//#define Myself 1

const std::string blank_space_sep = " ";
const std::string protocol_sep = "\n";

std::string Encode(const std::string &content)
{
    std::string pakage = std::to_string(content.size());
    pakage += protocol_sep;
    pakage += content;
    pakage += protocol_sep;

    return pakage;
}

bool Decode(std::string &pakage, std::string *content)
{
    std::size_t pos = pakage.find(protocol_sep);
    if(pos == std::string::npos) return false;
    std::string len_str = pakage.substr(0, pos);
    std::size_t len = std::stoi(len_str);
    std::size_t total_len = len_str.size() + len + 2;
    if(pakage.size() < total_len);

    *content = pakage.substr(pos+1, len);
    pakage.erase(0, total_len);

    return true;
}

class Request
{
public:
    Request(int x, int y, char op)
    :_x(x)
    ,_y(y)
    ,_op(op)
    {}

    Request()
    {}

    ~Request()
    {}
public:
    bool Serialize(std::string *out)
    {
#ifdef Myself
        //构建报文的有效载荷
        std::string s = std::to_string(_x);
        s += blank_space_sep;
        s += _op;
        s += blank_space_sep;
        s += std::to_string(_y);
        *out = s;
        return true;
#else
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["op"] = _op;
        Json::FastWriter w;
        *out = w.write(root);
        return true;
#endif
    } 

    bool Deserialize(const std::string &in)
    {
#ifdef Myself
        std::size_t left = in.find(blank_space_sep);
        if(left == std::string::npos) return false;
        std::string part_x = in.substr(0,left);

        std::size_t right = in.rfind(blank_space_sep);
        if(right == left) return false;
        std::string part_y = in.substr(right+1);

        if(left+2 != right) return false;
        _op = in[left+1];
        _x = std::stoi(part_x);
        _y = std::stoi(part_y);
#else
        Json::Value v;
        Json::Reader r;
        r.parse(in, v);
        _x = v["x"].asInt();
        _y = v["y"].asInt();
        _op = v["op"].asInt();
        return true;
#endif
    }

    void DebugPrint()
    {
        std::cout<<"新请求构建完成 ："<<_x<<_op<<_y<<"= ?"<<std::endl;
    }
public:
    int _x;
    int _y;
    char _op;
};

class Response
{
public:
    Response(int result, int code)
    :_result(result)
    ,_code(code)
    {}

    Response()
    {}

    ~Response()
    {}
public:
    bool Serialize(std::string *out)
    {
#ifdef Myself
        std::string s = std::to_string(_result);
        s += blank_space_sep;
        s += std::to_string(_code);
        *out = s;
        return true;
#else
        Json::Value root;
        root["result"] = _result;
        root["code"] = _code;
        Json::FastWriter w;
        w.write(root);
        return true;
#endif
    }

    bool Deserialize(const std::string &in)
    {
#ifdef Myself
        std::size_t pos = in.find(blank_space_sep);
        if(pos == std::string::npos) return false;
        std::string part_left = in.substr(0,pos);
        std::string part_right = in.substr(pos+1);

        _result = std::stoi(part_left);
        _code = std::stoi(part_right);
#else
        Json::Value v;
        Json::Reader r;
        r.parse(in, v);
        _result = v["result"].asInt();
        _code = v["code"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout<<"从服务器中得到结果,result: "<<_result<<"code: "<<_code<<std::endl;
    }
public:
    int _result;
    int _code; //0 正确的运算
};